import java.util.HashMap;

public class ReadMe {
    /**
     * 2022-9-21 java基础环境安装与配置
     * 思路？
     * 模拟用户登录：
     * 1.登录窗口
     * 2.输入用户信息
     * 3.点击登录按钮
     * 4.验证用户名或者密码输入的格式是否正确
     * 5.进行校验，用户名和密码是否和正确的用户名和密码一致
     * 6.如果一致，则提示登录成功
     * 7.如果不一致，则提示登录失败，然后让用户重新输入用户名和密码
     * --------------------------
     * 注释：
     * 单行注释
     * 文本注释
     * 多行注释
     */
    /**
     * 2022-9-22 基础语法和算术运算符
     * 1.所有的包都是小写
     * 2.关键字，Java赋予特殊含义，在Java里面用小写。idea一般会高亮显示
     * 3.类名的命名：大驼峰命名，多个单词，每个单词的首字母大写
     * 4.字面量：能够看到就知道是什么意思
     * 5.字符用单引号括起来，不能只是单引号，如果是空字符，则可以按一个空格
     * 6.字符，就单个英文字母和数字和中文字符，特殊字符 ：注意：单个
     * 7.字符串：将多个字符串起来构成一个整体
     * 8.java严格区分大小写
     * 8.变量：经常变化的量，会在内存里面开辟一个空间（容器），用于存常量
     * 9.每次对同一个变量进行赋值的时候，都会覆盖以前的值
     * 10.debug  就是打断点的意思
     *      step over F8  下一步
     *      F9 跳转到下一个断点，如果后面没有断点，则直接跳出程序(程序结束)
     *      可以一行一行代码看着执行
     * 11.java一般用分号表示一条语句结束
     * 12.java一条语句定义多个变量，则用逗号
     * 13.变量在使用之前一定要进行赋值
     * 14.在方法里面的变量叫做局部变量
     * 15.在类里面的变量叫做全局变量
     * ---------------------------
     * 16.标识符：就是给类，方法，变量起的名字
     * 17.标识符命名规则：全英文即可
     *      类：大驼峰命名   GoodStudent
     *      包：全小写  good.student 点就表示创建一个包（多创建一个文件夹）
     *      变量：小驼峰 goodStudent
     *      方法名：小驼峰  goodStudent
     *      常量：全大写  GOOD_STUDENT  下划线给开
     * --------------------------------------
     * 18.计算机最小的存储单位？字节 一个字节八个bit位
     * 19.计算机最小的操作单位？bit 位  0 1
     * 20。bit位  如果是有符号，第一个表示符号正负，
     * 21.数字的默认数据类型是int
     * 22.小数默认的数据类型是double
     * 23.数据类型：八个
     *      四个整型：整数  byte 1  short 2 int（默认） 4 long 8
     *      2个浮点型：小数  float  4   double(默认)   8
     *      1个字符型：单子字符   char
     *      1个布尔型： boolean   true  false(默认值)
     *    对应几个数据类型的默认值：和书写方式
     *    long  lll=4L；
     *    float  ff=1F;
     *    double dd=2D;
     *--------------------------------------
     * 24.键盘录入 Scanner
     * 25.如果两个都是整型，相除，得到的是向下取整的整数
     * 26.如果两个数相除，有一个是浮点数，则结果是浮点数
     * 27.整数和字符串相加就是字符串
     * 28.如果想在字符串拼接时进行算术运算，则需要将运算的表达式用括号括起来
     */
    /**
     * 2022-9-23 运算符和分支
     * 1.-- ++
     *      1）如果单独使用 --，++，则都是一样的结果
     *      2）如果有表达式，前面有变量参与，则++i；表示先加1，在赋值，
     *      3）如果有表达式，前面有变量参与，则i++；表示先赋值，在加1，
     * 2.隐式转换---将范围小的转换为大的，将小的赋值给大的
     * 3.强制转换---将范围大的强制转换为范围小的 int i=3;byte ee = (byte)i;
     * 4.隐式的强制转换  byte b=10;  b+=3;
     * 5.关系运算符
     * 6.逻辑运算符
     *      & 两边同时为true的时候才能为true，只要有一个为false则结果为false
     *      | 两边同时为false的时候才为false，只要有一个为true则为true
     *      ！取反
     *      ^ 相同为false  不同为true
     *    逻辑短路运算符
     *      &&  只要左边为false，右边就不执行，结果为false
     *      ||  只要左边为true，右边不执行，结果为true
     * 7.三元运算符
     *      数据类型  变量名  =     布尔值?返回值1：返回值2；
     *       先判断？左边的布尔值为true还是false
     *        如果为true，则将返回值1返回给变量
     *        如果为false，则将返回值2返回给变量
     * 8.优先级   先算括号里面，先乘除后加减，赋值运算符最好
     *           &&逻辑短路与的优先级大于逻辑短路或||
     * 9.分支    if  else   很多时候可以用三元运算符代替 ：三元运算符必须要有返回值
     *          如果大括号里面只有一行代码，则可以省略大括号
     *          建议都加上大括号
     *
     *
     */
    /**
     * 2022-9-26 循环语句
     * 1.for
     *      1）初始化
     *      2）判断语句
     *      3）条件语句
     *      4）循环体
     *      5）循环体里面可以做一些判断
     *      6）局部变量 在跳出方法或者跳出当前{}后就被释放了
     * 2.while 循环   可以理解和for循环差不多
     * 3.do while 循环  循环体里面的语句至少会执行一次
     * 3.break 跳出当前循环
     * 4.continue  当前循环后面的内容不执行，直接执行下一次循环
     * 5.break和continue只能跳出当前循环
     * 6.如果想要跳出整个循环（包括嵌套）用return，其实，return是跳出方法
     */
    /**
     * 2022-9-27 数组和二维数组
     * 1.数组的静态定义
     * 2.数组的格式
     * 3.数组的取值
     * 4.数组的遍历
     * 5.数组的求和
     * 6.如果用if，else，if里面没有任何代码，那么可以不要else
     * 以后少用else嵌套
     * 7.动态数据的定义，遍历
     * 8.数组的异常：下标越界  空指针
     * 9.二维数组   int[][] arr=new int[i][j];
     * i表示二维数组的长度
     * j表示二维数组里面元素的长度
     * 注意：j是不固定的
     * 10.内存图：地址存栈，创建new  存堆
     */
    /**
     * 2022-9-28 方法
     * 1.方法一共按照功能模块进行分类
     * 2.一个方法里面只干一件事情
     * 3.如果其他地方要干这个事情，就可以直接调用当前的方法
     * 4.实际的参数  实参 就是调用方法的时候赋值给方法的值
     * 5.形参  一般情况下 就是方法的参数
     * 6.以后方法最好有一个返回值
     * 7.如果不想知道方法里面到底做了什么或者需要又什么样的反馈，则不需要又返回值
     * 8.有返回值的方法   int  getAge(String name){
     *     return 19;
     * }    int表示返回值数据类型   19表示返回的值
     * 最终调用int age=getAge("张三");得到的是age=19；
     * 9.返回值如果为null，那么返回的数据类型必须用引用数据类型接收
     * ------------------------------------------------------
     * 1)方法的定义格式
     * 2）有参数的方法
     * 3）形参和实参
     * 4）有返回值的方法
     * -------------------------------
     * java重载
     * 方法名相同，参数类型，个数，顺序不同
     * 方法参数如果个数有多个，而且数据类型一样，则用数组，集合
     * 如果参数不固定，则用可变参数
     *   private static int add(int... arr)
     *   如果可变参数有多个，则可变参数的数组一定要放在最后
     *   private static int add(String name,int... arr)
     */
    /**
     * 2022-9-29 案例讲解
     * 1.Java有没有引用传递？没有  Java只有值传递
     */
    /**
     * 2022-9-30 面需对象
     * 1.在Java里面，什么情况下才能称为对象？一般情况下用new关键字创建的就叫做对象
     * 2.       类  和   对象
     *          属性        脸，手，衣服    用名词来描述对象的特征
     *          方法     煮饭，睡觉，蹦迪  用动词来描述对象的行为
     * 3.局部变量可以不赋值，但是只要用它就必须赋初始值
     * 4.this指谁调用他，他就指向谁
     * 5.每一个类都默认有一个构造方法(无参数的构造方法)
     * 6.默认不屑修饰符  只能在当前包使用
     * 7.构造方法也可以重载
     * 8.只要写了有参数的构造方法，则默认的无参数的构造方法失效，应该手动添加一个无参数的构造方法
     * 9.构造方法有没有返回值？一定是有返回值
     * 10.完整的方法
     *  修饰符（权限修饰符public，特征修饰符static）  返回值数据类型String 方法名methodName （参数数据类型 参数名） 抛出异常{
     *     执行体
     *     return 返回值
     * }
     *   public static String methodName(String[] args) throws Exception {
     *         System.out.println("aaa");
     *         return "";
     *     }
     * 11.代码的执行顺序:静态代码块先于代码块执行，先于构造方法执行 和书写顺序无关
     * 12.修饰符
     *      1）private  只有当前类可以调用
     *      2）public   所有的类都可以调用（当前项目）
     *      3）protected  一般用于子类和父类
     *      4）默认不屑  只能在当前包（必须一个级别）
     * 13.封装：就是把不想显示的隐藏起来，给外部提供一个接口即可
     * 14.定义Java 对象的步骤：
     *      1）定义属性（所有属性修饰符全部为private）
     *      2）给所有属性添加set和get方法
     *      3)定义构造方法（无参数的和全参数的都定义一个）
     * 15.对象拆分：找对象
     *      1）按照功能模块拆分（小功能）
     *      2）拆成最小单位（粒度）地址：（家庭地址，学校地址，情人地址）
     *      3）最好对象之间不存在关联
     */
    /**
     * 2022-10-8 字符串
     * 面试题：String aa=new String("bb");请问创建了几个对象？
     * String s1="abc";
     * String s2="ab";
     * String s3=s2+"c";
     * String s4="a"+"b"+"c";
     * s1==s3;false为什么? 会先创建一个StringBuilder对象，然后将值赋值StringBuilder，在转换为String
     * 因为StringBuilder创建的时候会重新创建一个对象
     * s1==s4;true为什么? 先计算在赋值
     * ----------------------------------------------
     * 1.api接口文档查询
     * 2.String的定义 构造方法
     * 3.String  ==（比较地址） 和equals （比较内容）
     * 4.String的遍历
     *      1）charAt(int index)通过索引拿到当前对应的字符
     *      2)toCharArray（）将字符串转换为字符数组
     *      3）length()  String和数组有没有length属性，有没有length方法？
     * 5.String的subString
     * 6.split 分割：将字符串以某个规则进行分割成字符串数组
     * 7.replace  替换 replace（旧，新）
     * 8.contains 包含什么字符
     * 9.endWith 以什么结束
     * 10.startWith  以什么开始
     * 11.toUpperCase 将字符串转换为全大写
     * 12.toLowerCase 将字符串转换为全小写
     * 13.trim() 去掉字符串左右两端的空格
     * 14.indexOf(char c) 通过字符找到当前字符对应的索引
     */
    /**
     * 2022-10-9 集合基础
     * 1.数组打印的是地址
     * 2.集合打印的是具体的值
     * 3.快捷键
     *     ctrl+d  复制当前一行
     *     ctrl+shift+↑   将选中的行上移
     *     ctrl+shift+下键  将选中的行下移
     *     ctrl+alt+l   将代码格式化对齐
     * 4. list.remove(list.get(i));删除元素，删除完后list的大小减一
     * 5.add(model)
     * 6.add(index,model)
     * 7.set(index,model)
     *
     */
    /**
     * 2022-10-10 面需对象继承
     * 1.父类的私有属性或者方法子类也不能调用
     * 2.子类可以使用父类的公有属性
     * 3.子类的内容是子类加上父类，是子类和父类的并集
     * 4.重载：如果子类和父类 子类的方法名和父类的方法名一致，且参数一致，
     *      则调用子类的方法时，父类的方法就被子类覆盖了
     *      如果子类没有这个方法，则直接调用父类的方法
     * 5.@Override 注解   用于判断子类和父类的方法是否时重写
     * 6.可以不要@Override注解，也可以表示重写
     * 7.所有的引用类型的父类都是Object类，
     * 8.Object类的常用方法？
     *      equals()
     *      toString()
     *      hashcode()
     *      clone()
     *      getClass()
     *      finalize()
     *      wait()
     *      notify()
     * 9.调用子类的变量，首先是就近原则，
     *      先从局部变量里面找
     *      在全局变量
     *      在父类的全局变量
     *      会一直往上找，直到Object类
     * 10.类默认有一个无参数的构造方法
     * 11.子类的构造方法默认调用了一个父类的构造方法super()
     * 12.super只能放在第一行,所以，永远先执行父类的构造方法
     * 13.父类最好默认给一个无参数的构造方法，因为子类构造方法第一行会调用super()
     * 14.子类重写父类的方法，那么父类的方法就不会执行，所有代码就应该写在子类
     * 15.java不允许类多继承，同时继承多个类
     * 16.protected 受保护的修饰符  一般情况下 用于子类和父类
     * 17.this并不一定是指当前对象，谁调用就是谁
     * -------------------------------------------------
     * 继承：将对象之间相同的属性和方法提取到一个父类
     * 子类可以有自己独有的内容
     * ----------------------------------
     * 18.重写，子类的返回值一定小于等于父类的范围
     * 19.重写，修饰符，子类一定大于等于父类的修饰符范围
     * 20.public >  protected > 默认不写 > private
     * -------------------------
     * 面试题：重载和重写的区别？
     * ----------------------------------
     * 修饰符：权限修饰符：特征修饰符
     * 访问修饰符：非访问修饰符
     * private 只能当前类调用
     * public  所有的包都可以调用
     * protected  子类和父类之间调用
     * 默认不写  在同一个包里面调用
     * ----------------------------------------
     * 21.被final修饰的类不能被继承
     * 22.被final修饰的变量为常量，一定要赋初始值？
     * 23.一般我们说是的常量叫做全局变量，成员变量
     * 24.如果被final修饰的局部变量不一定要赋值，只不过用之前要赋值
     * 25.被final修饰的变量不能被再次赋值
     * 26.如果不想自己的方法被重写，则定义final修饰
     * ------------------------------------
     * 27.final,static修饰类，方法和属性的区别？
     * 28.被static修饰的变量为可以共享的值，内存里面只能存一个，如果被修改了，就是覆盖以前的值
     * 29.无论对象被创建多少次，或者被修改多少次，都是修改的同一个变量
     * 30.被static修饰的变量直接通过  类名.变量名  调用
     * 31.非静态方法可以直接调用静态方法和非静态方法
     * 32.静态方法可以直接调用静态方法，如果要调用非静态方法，则用对象.方法();
     * 33.static什么时候进入内存？在类编译成.class文件时就加载到内存
     * 34.static一般用于工具类，然后将构造方法写成私有的构造方法
     * 35.静态变量和代码块都只加载一次，
     * ----------------------------
     * 1)继承
     * 2）修饰符
     *      1）final
     *      2）static
     * ------------------------
     * 调用关系？怎么去调用？类，变量，方法
     *
     */
    /**
     * 2022-10-11 多态
     * 1.快捷键：提示方法里面的参数显示 ctrl+p
     * 2.instanceof 判断左边的是否是右边的父类,判断是否为同一数据类型
     * 3.类里面如果有方法没有方法体，则代表当前方法必须为抽象方法
     * 4.如果当前方法为抽象方法，则类必须为抽象类，用abstract修饰
     * 5.抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
     * 6.抽象类不能进行实例化，创建对象：如果非要实例化，则必须重写里面所有的抽象方法
     * 7.抽象类和普通类的区别？
     *      1)抽象类有abstract
     *      2）如果有子类，必须实现里面所有抽象方法或者是抽象类
     *      3)不能实例化，就是不能创建对象，只能通过子类创建对象
     * 8.为什么要写抽象类？
     *      1)必须让子类继承固定的方法
     *      2）子类重写父类的方法
     * 9.常量：static  final  String NAME_AGE="aa"；
     * 10.将字符转换为大小写：快捷键  ctrl+shift+u
     * 11.执行代码顺序：先执行static
     *
     */
    /**
     * 2022-10-12 接口和内部类和lambda表达式
     * 1.没有用class修饰的是不是不叫类？
     * 2.接口是不是类？
     * 3.抽象类是不是类？
     * --------------------------
     * 所有的大驼峰表示的对象都是类
     * 只不过，接口是一个特殊的抽象类
     * 接口其实是对抽象类里面的抽象方法的提取
     * 4.接口里面的方法默认为抽象方法，那么修饰符？
     * 5.类才有继承extends，接口只能写实现implements
     * 6.一般情况下接口里面只写一个抽象方法
     * 7.接口里面的属性，必须是常量 而且要赋值
     * 8.接口里面没有构造方法
     * 9.抽象类和接口的区别？一般情况下，如果接口里面抽象方法太多，那么把里面的抽象方法提取出来（接口）
     * 10.抽象类，
     *      一般情况下如果里面全是常量，用枚举
     *      如果全是抽象方法，用接口
     * 11.只要以后看到属性，首先想到私有，private
     * 12.成员内部类：和方法同级，
     * 13.局部内部类：在方法里面创建一个类
     * 14.匿名内部类：在方法里面，对一个接口或者抽象类进行实例化，必须重写里面的抽象方法
     * 15.难点：怎么在这些类里面调用其他类里面的属性或者方法
     * ------------------------------------------------------
     * 16.局部内部类在其他地方访问不了
     * ---------------------------------------
     * 17.lambda表达式规则：
     *      method(){}
     *      ()->{}
     *      如果代码块里面只有一行代码，则{}可以省略
     *      userInner((name, age) -> System.out.println(name + age));
     *       userInner((String name, int age) -> System.out.println(name + age));
     *    lambda表达式的前提？
     *      1）必须是接口
     *      2）必须接口里面只有一个抽象方法
     *    如果（）里面只有一个参数，则可以不要小括号
     *
     */
    /**
     * 2022-10-13 常用API
     * 1.会把以后常用的代码封装到工具类
     * 2.工具类一般用私有的构造方法，通过类名.方法名进行调用
     * 3.BigDecimal一般用于小数，让其更加精准，只不过用构造方法的时候要加引号
     * 4.一般在价格：或者进度比较高的情况下用BigDecimal
     *      BigDecimal.ROUND_FLOOR  直接不要后面的：去掉尾巴
     * 5.将字符串转换为int  Integer.valueOf("10")
     * 6.类的所有属性推荐全部用引用类型
     * 7.parseInt 转换为int类型
     * 8.valueOf 转换为Integer类型
     * 9.Integer.parseInt("10")
     *      前提
     *      1.必须参数为数字，不能有字符
     *      2.必须为整数，不能为小数
     */
    /**
     * 2022-10-14
     * 1.throws ParseException为什么会报错？
     *      Java会对常用的代码会自检，如果经常会报错的地方给程序员一个提示
     * 2.有些地方不用强制抛出：
     * 3.空指针NullPointerException
     * 4.正常情况下，出现异常，JVM会默认终止程序
     * 5.用throws抛出的异常一般为编译时异常
     * 6.如果出现异常后没有执行后面代码的意义，则直接抛出
     * 7.如果都不做异常处理，都是网上抛出，那么最终处理异常的是JVM
     * 8.一般情况下，出现异常最好自己处理，try  catch
     * 9.try  catch就是捕获异常
     * 10.finally一般情况下表示必须要执行的代码
     * 11.try  catch finally  假如说有return，
     *  那么finally里面的代码是在return之前执行还是之后执行？
     *  答案：在return之前执行，
     * 13.Date  现在不常用，因为里面很多方法过时，废弃
     * 14.SimpleDateFormat 对Date进行封装
     * 15.LocalDateTime 比SimpleDateFormat 对它进行简单的封装
     * 16.Clock  可以根据时区拿到时间
     * 17.Duration 比较两个时间之间的差(可以得到天，小时，分，秒等)
     * 18.DateTimeFormatter 和SimpleDateFormat差不多
     * -----------------------------
     * 日期：日期怎么格式化，怎么相互转换
     */
    /**
     * 2022-10-17集合list
     * 1.集合里面不能存基本类型只能是引用类型
     */
    /**
     * 2022-10-18 集合set
     * 1.set去重
     * 2.set自动进行了排序
     * 3.自然排序：将对象实现接口implements Comparable<Student> ，
     *          重写里面的 public int compareTo(Student o)
     * 4.比较强排序：
     *      1.创建一个带参数的构造方法Set<Student> set = new TreeSet<>(new Comparator<Student>() {
     *      2.重写 public int compare(Student o1, Student o2) {
     *      3.定义规则
     *
     */
    /**
     * 2022-10-19 集合map
     * 复习：set  特点：去重，不能用for，无序
     * treeSet  树，普通二叉数，排序（搜索，查找），平衡二叉树，红黑树
     * hashSet  hash表：
     * ---------------------------------
     * map 存数据的时候，如果key值一致，那么会覆盖以前的value值
     *
     * ----------------------------
     * 总结
     *           list               set             map
     *  共同点：集合
     *  不同点：
     *    顺序   存取有顺序          无序             无序
     * 是否进行排序  无               有 （自然和比较器） 有（自然和比较器）
     * 数据结构   数组和链表           树，hash        数和hash
     * 可重复     可以               不可以           key不可以，value可以
     * 是否可以存null  可以            可以              key不可以value可以
     * ---------------------------------------------
     * filter
     * concat
     * forEach
     * collect
     * toMap
     *
     */
    /**
     * 2022-10-20 file类
     * 复习：
     * stream：
     *  1.新建一个list集合
     *  2.将list集合转换为Stream流
     *  3.过滤filter （过滤）
     *  4.concat 连接   将两个集合合并在一起
     *  5.limit  取得里面的某几个元素
     *  6.skip   跳过某几个元素 取得其他元素
     *  7.distinct  去掉重复
     *  8.collector   将前面的功能做完以后收集到一个新的集合里面去
     *  9.可以收集到集合list
     *  10.可以收集到set
     *  11.可以收集到map
     *  注意：里面很多可以用lambda表达式,如果用lambda 必须满足条件
     *     1)接口或抽象类
     *     2）里面只有一个抽象方法
     *     3)()->{}
     *  -----------------------------------------
     * 已经学过的常用API：
     *      Math
     *      Scanner
     *      System
     *      Random
     *      String
     *      Collection
     *      List
     *      ArrayList
     *      LinkedList
     *      Set  HashSet TreeSet
     *      Map HashMap  TreeMap
     *      Iterator
     *      Date  SimpleDateFormat LocalDateTime
     *--------------------------------------------
     * file类
     * 1.创建文件
     * 2.创建文件夹
     * 3.递归
     * 4.删除
     *
     */
    /**
     * 2022-10-21 io流
     * 1.以后代码里面最好不要出现字符，（固定常量），
     *  如果是常量那么应当单独写一个类用于调用
     *  所以以后一般常量在枚举
     */
    /**
     * 2022-10-24 其他IO流
     * 1.每次操作完IO流，都要记得关闭流
     * 2.只要实现了implements Serializable序列号，则默认在里面新建一个常量
     *       private static final long serialVersionUID = 这个值是系统随机的;
     * 3.对象流，可以操作对象，对对象进行读取
     * 4.Properties流，底层是Map
     *
     */
    /**
     * 2022-10-25 网络编程基础
     * 1.网络编程入门
     *      1）ip
     *      2）端口
     *      3)协议
     * 2.UDP
     *      1）单播
     *      2）组播
     *      3）广播
     *      ---------------------------------------
     *      客户端：
     *      1.创建对象DatagramSocket  用来接收数据
     *      2.创建对象DatagramPacket  将数据打包
     *      3.发送数据 socket.send(packet);
     *      4.关闭socket
     *      ---------------------------------
     *      服务端：
     *       1.创建对象DatagramSocket  用来接收数据
     *       2.创建对象DatagramPacket  将数据打包
     *       3.接收客户端发送的信息 datagramSocket.receive(packet);
     *       4.将接收的信息进行解析：打印到控制台
     *       5.关闭socket
     *       --------------------------------
     *       组播：
     *       服务端：
     *       1）创建组播对象MulticastSocket
     *       2）将对象加入到组播地址：multicastSocket.joinGroup(InetAddress.getByName("224.0.3.3"));
     *       3）multicastSocket.receive(datagramPacket);
     *       客户端：和单播一样：将以前的地址换成组播地址
     *       ------------------------------
     *       广播：将地址换成广播地址
     * -----------------------------------------------------------
     * TCP协议： 通过IO流的方式进行发送或接收数据
     *      单次发送
     *      客户端：
     *      1）创建Socket对象，用于得到流
     *      2）输入发送信息（可以是文字，文件）
     *      3）通过输出流写入到socket流
     *      4）关闭socket和流
     *      服务端：
     *      1）创建服务端的socket：ServerSocket
     *      2）建立接收消息通道：Socket socket = serverSocket.accept();
     *      3）得到socket流
     *      4）读取得到的流：
     *      5）将流进行解析成文字或者文件
     *      6）关闭流
     *      ----------------------------------
     *      如果要进行响应，则只需要做逻辑处理即可
     */
    /**
     * 2022-10-26 注解反射枚举
     * 1.类加载器
     * 2.反射：
     *      1）得到类
     *      2）得到对象
     *      3）得到构造方法
     *      4）得到属性
     *      5）得到方法
     *      6）可以对所有的修饰符进行取值赋值
     * 3.枚举
     *      1）定义
     *      2）构造方法
     *      3）得到里面的参数值
     * 4.注解
     *      1）自定义注解
     *      2）元注解：jdk自带的注解
     * 5.测试用例  学会测试自己的代码
     * 6.日志
     * 7.xml
     */




}
